package org.convallaria.system.biz.util;

import org.convallaria.framework.common.constants.sys.OperLogConstants;
import org.convallaria.system.biz.entity.SysOperLog;

/**
 * 系统操作日志工具类
 * 
 * 功能特性：
 * - 提供操作日志相关的业务逻辑判断方法
 * - 提供操作状态、业务类型等描述信息
 * - 提供操作日志数据验证方法
 * - 提供操作日志信息格式化方法
 * 
 * 设计原则：
 * - 纯静态方法，无状态
 * - 业务逻辑与实体类分离
 * - 便于单元测试
 * - 提高代码可维护性
 * 
 * @author convallaria
 * @since 1.0.0
 */
public class SysOperLogUtils {

    // ==================== 状态判断方法 ====================

    /**
     * 判断操作是否正常
     * 
     * @param operLog 操作日志对象
     * @return true=正常，false=异常
     */
    public static boolean isOperNormal(SysOperLog operLog) {
        if (operLog == null || operLog.getStatus() == null) {
            return false;
        }
        return OperLogConstants.isOperNormal(operLog.getStatus());
    }

    /**
     * 判断操作是否异常
     * 
     * @param operLog 操作日志对象
     * @return true=异常，false=正常
     */
    public static boolean isOperException(SysOperLog operLog) {
        if (operLog == null || operLog.getStatus() == null) {
            return false;
        }
        return OperLogConstants.isOperException(operLog.getStatus());
    }

    /**
     * 判断操作状态是否有效
     * 
     * @param status 状态值
     * @return true=有效，false=无效
     */
    public static boolean isValidOperStatus(Integer status) {
        return OperLogConstants.isValidOperStatus(status);
    }

    // ==================== 业务类型判断方法 ====================

    /**
     * 判断是否为新增操作
     * 
     * @param operLog 操作日志对象
     * @return true=新增，false=其他
     */
    public static boolean isInsertOperation(SysOperLog operLog) {
        if (operLog == null || operLog.getBusinessType() == null) {
            return false;
        }
        return OperLogConstants.isInsertOperation(operLog.getBusinessType());
    }

    /**
     * 判断是否为修改操作
     * 
     * @param operLog 操作日志对象
     * @return true=修改，false=其他
     */
    public static boolean isUpdateOperation(SysOperLog operLog) {
        if (operLog == null || operLog.getBusinessType() == null) {
            return false;
        }
        return OperLogConstants.isUpdateOperation(operLog.getBusinessType());
    }

    /**
     * 判断是否为删除操作
     * 
     * @param operLog 操作日志对象
     * @return true=删除，false=其他
     */
    public static boolean isDeleteOperation(SysOperLog operLog) {
        if (operLog == null || operLog.getBusinessType() == null) {
            return false;
        }
        return OperLogConstants.isDeleteOperation(operLog.getBusinessType());
    }

    /**
     * 判断业务类型是否有效
     * 
     * @param businessType 业务类型
     * @return true=有效，false=无效
     */
    public static boolean isValidBusinessType(Integer businessType) {
        return OperLogConstants.isValidBusinessType(businessType);
    }

    // ==================== 操作类别判断方法 ====================

    /**
     * 判断是否为后台用户操作
     * 
     * @param operLog 操作日志对象
     * @return true=后台用户，false=其他
     */
    public static boolean isManageOperator(SysOperLog operLog) {
        if (operLog == null || operLog.getOperatorType() == null) {
            return false;
        }
        return OperLogConstants.isManageOperator(operLog.getOperatorType());
    }

    /**
     * 判断是否为手机端用户操作
     * 
     * @param operLog 操作日志对象
     * @return true=手机端用户，false=其他
     */
    public static boolean isMobileOperator(SysOperLog operLog) {
        if (operLog == null || operLog.getOperatorType() == null) {
            return false;
        }
        return OperLogConstants.isMobileOperator(operLog.getOperatorType());
    }

    /**
     * 判断操作类别是否有效
     * 
     * @param operatorType 操作类别
     * @return true=有效，false=无效
     */
    public static boolean isValidOperatorType(Integer operatorType) {
        return OperLogConstants.isValidOperatorType(operatorType);
    }

    // ==================== 数据验证方法 ====================

    /**
     * 验证操作日志信息是否完整
     * 
     * @param operLog 操作日志对象
     * @return true=完整，false=不完整
     */
    public static boolean isValidOperLog(SysOperLog operLog) {
        if (operLog == null) {
            return false;
        }
        
        // 状态验证
        if (!isValidOperStatus(operLog.getStatus())) {
            return false;
        }
        
        // 业务类型验证
        if (operLog.getBusinessType() != null && !isValidBusinessType(operLog.getBusinessType())) {
            return false;
        }
        
        // 操作类别验证
        if (operLog.getOperatorType() != null && !isValidOperatorType(operLog.getOperatorType())) {
            return false;
        }
        
        // 字段长度验证
        if (!OperLogConstants.isValidTitle(operLog.getTitle())) {
            return false;
        }
        if (!OperLogConstants.isValidMethod(operLog.getMethod())) {
            return false;
        }
        if (!OperLogConstants.isValidRequestMethod(operLog.getRequestMethod())) {
            return false;
        }
        if (!OperLogConstants.isValidOperName(operLog.getOperName())) {
            return false;
        }
        if (!OperLogConstants.isValidOperIp(operLog.getOperIp())) {
            return false;
        }
        if (!OperLogConstants.isValidCostTime(operLog.getCostTime())) {
            return false;
        }
        
        return true;
    }

    /**
     * 验证模块标题格式
     * 
     * @param title 模块标题
     * @return true=有效，false=无效
     */
    public static boolean isValidTitle(String title) {
        return OperLogConstants.isValidTitle(title);
    }

    /**
     * 验证方法名称格式
     * 
     * @param method 方法名称
     * @return true=有效，false=无效
     */
    public static boolean isValidMethod(String method) {
        return OperLogConstants.isValidMethod(method);
    }

    /**
     * 验证请求方式格式
     * 
     * @param requestMethod 请求方式
     * @return true=有效，false=无效
     */
    public static boolean isValidRequestMethod(String requestMethod) {
        return OperLogConstants.isValidRequestMethod(requestMethod);
    }

    /**
     * 验证操作人员格式
     * 
     * @param operName 操作人员
     * @return true=有效，false=无效
     */
    public static boolean isValidOperName(String operName) {
        return OperLogConstants.isValidOperName(operName);
    }

    /**
     * 验证IP地址格式
     * 
     * @param operIp IP地址
     * @return true=有效，false=无效
     */
    public static boolean isValidOperIp(String operIp) {
        return OperLogConstants.isValidOperIp(operIp);
    }

    /**
     * 验证消耗时间格式
     * 
     * @param costTime 消耗时间
     * @return true=有效，false=无效
     */
    public static boolean isValidCostTime(Long costTime) {
        return OperLogConstants.isValidCostTime(costTime);
    }

    // ==================== 格式化方法 ====================

    /**
     * 格式化操作日志显示名称
     * 
     * @param operLog 操作日志对象
     * @return 格式化后的显示名称
     */
    public static String formatDisplayName(SysOperLog operLog) {
        if (operLog == null) {
            return "未知操作记录";
        }
        
        String displayName = operLog.getTitle();
        if (displayName == null || displayName.trim().isEmpty()) {
            displayName = operLog.getMethod();
        }
        
        if (displayName == null || displayName.trim().isEmpty()) {
            displayName = "未知操作";
        }
        
        return displayName;
    }

    /**
     * 格式化操作日志完整信息
     * 
     * @param operLog 操作日志对象
     * @return 格式化后的完整信息
     */
    public static String formatOperLogInfo(SysOperLog operLog) {
        if (operLog == null) {
            return "操作日志信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("操作ID: ").append(operLog.getOperId()).append(", ");
        sb.append("模块标题: ").append(operLog.getTitle()).append(", ");
        sb.append("业务类型: ").append(getBusinessTypeDesc(operLog.getBusinessType())).append(", ");
        sb.append("操作人员: ").append(operLog.getOperName()).append(", ");
        sb.append("状态: ").append(getOperStatusDesc(operLog.getStatus())).append(", ");
        sb.append("消耗时间: ").append(operLog.getCostTime()).append("ms");
        
        return sb.toString();
    }

    /**
     * 格式化操作环境信息
     * 
     * @param operLog 操作日志对象
     * @return 格式化后的环境信息
     */
    public static String formatEnvironmentInfo(SysOperLog operLog) {
        if (operLog == null) {
            return "环境信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("IP地址: ").append(operLog.getOperIp()).append(", ");
        sb.append("操作地点: ").append(operLog.getOperLocation()).append(", ");
        sb.append("请求方式: ").append(operLog.getRequestMethod()).append(", ");
        sb.append("请求URL: ").append(operLog.getOperUrl());
        
        return sb.toString();
    }

    /**
     * 格式化性能信息
     * 
     * @param operLog 操作日志对象
     * @return 格式化后的性能信息
     */
    public static String formatPerformanceInfo(SysOperLog operLog) {
        if (operLog == null) {
            return "性能信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("消耗时间: ").append(operLog.getCostTime()).append("ms");
        
        if (operLog.getCostTime() != null) {
            if (operLog.getCostTime() > 5000) {
                sb.append(" (慢操作)");
            } else if (operLog.getCostTime() > 1000) {
                sb.append(" (较慢)");
            } else if (operLog.getCostTime() > 500) {
                sb.append(" (正常)");
            } else {
                sb.append(" (快速)");
            }
        }
        
        return sb.toString();
    }

    // ==================== 描述信息方法 ====================

    /**
     * 获取操作状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    public static String getOperStatusDesc(Integer status) {
        return OperLogConstants.getOperStatusDesc(status);
    }

    /**
     * 获取业务类型描述
     * 
     * @param businessType 业务类型
     * @return 业务类型描述
     */
    public static String getBusinessTypeDesc(Integer businessType) {
        return OperLogConstants.getBusinessTypeDesc(businessType);
    }

    /**
     * 获取操作类别描述
     * 
     * @param operatorType 操作类别
     * @return 操作类别描述
     */
    public static String getOperatorTypeDesc(Integer operatorType) {
        return OperLogConstants.getOperatorTypeDesc(operatorType);
    }

    // ==================== 业务逻辑方法 ====================

    /**
     * 判断操作日志是否可以删除
     * 
     * @param operLog 操作日志对象
     * @return true=可以删除，false=不能删除
     */
    public static boolean canDelete(SysOperLog operLog) {
        if (operLog == null) {
            return false;
        }
        
        // 所有操作日志都可以删除
        return true;
    }

    /**
     * 判断操作日志是否可以编辑
     * 
     * @param operLog 操作日志对象
     * @return true=可以编辑，false=不能编辑
     */
    public static boolean canEdit(SysOperLog operLog) {
        if (operLog == null) {
            return false;
        }
        
        // 操作日志通常不允许编辑
        return false;
    }

    /**
     * 判断操作日志是否可以使用
     * 
     * @param operLog 操作日志对象
     * @return true=可以使用，false=不能使用
     */
    public static boolean canUse(SysOperLog operLog) {
        if (operLog == null) {
            return false;
        }
        
        // 所有操作日志都可以使用
        return true;
    }

    /**
     * 判断操作日志是否为空
     * 
     * @param operLog 操作日志对象
     * @return true=为空，false=不为空
     */
    public static boolean isEmpty(SysOperLog operLog) {
        if (operLog == null) {
            return true;
        }
        
        return (operLog.getTitle() == null || operLog.getTitle().trim().isEmpty()) &&
               (operLog.getMethod() == null || operLog.getMethod().trim().isEmpty());
    }

    /**
     * 判断操作日志是否有效（非空且格式正确）
     * 
     * @param operLog 操作日志对象
     * @return true=有效，false=无效
     */
    public static boolean isValid(SysOperLog operLog) {
        return !isEmpty(operLog) && isValidOperLog(operLog);
    }

    /**
     * 判断是否为慢操作
     * 
     * @param operLog 操作日志对象
     * @return true=慢操作，false=正常操作
     */
    public static boolean isSlowOperation(SysOperLog operLog) {
        if (operLog == null || operLog.getCostTime() == null) {
            return false;
        }
        return operLog.getCostTime() > 5000; // 超过5秒为慢操作
    }

    /**
     * 判断是否为快速操作
     * 
     * @param operLog 操作日志对象
     * @return true=快速操作，false=其他
     */
    public static boolean isFastOperation(SysOperLog operLog) {
        if (operLog == null || operLog.getCostTime() == null) {
            return false;
        }
        return operLog.getCostTime() <= 500; // 500毫秒内为快速操作
    }

    /**
     * 判断是否为GET请求
     * 
     * @param operLog 操作日志对象
     * @return true=GET请求，false=其他
     */
    public static boolean isGetRequest(SysOperLog operLog) {
        if (operLog == null || operLog.getRequestMethod() == null) {
            return false;
        }
        return OperLogConstants.REQUEST_METHOD_GET.equals(operLog.getRequestMethod());
    }

    /**
     * 判断是否为POST请求
     * 
     * @param operLog 操作日志对象
     * @return true=POST请求，false=其他
     */
    public static boolean isPostRequest(SysOperLog operLog) {
        if (operLog == null || operLog.getRequestMethod() == null) {
            return false;
        }
        return OperLogConstants.REQUEST_METHOD_POST.equals(operLog.getRequestMethod());
    }

    /**
     * 判断是否为PUT请求
     * 
     * @param operLog 操作日志对象
     * @return true=PUT请求，false=其他
     */
    public static boolean isPutRequest(SysOperLog operLog) {
        if (operLog == null || operLog.getRequestMethod() == null) {
            return false;
        }
        return OperLogConstants.REQUEST_METHOD_PUT.equals(operLog.getRequestMethod());
    }

    /**
     * 判断是否为DELETE请求
     * 
     * @param operLog 操作日志对象
     * @return true=DELETE请求，false=其他
     */
    public static boolean isDeleteRequest(SysOperLog operLog) {
        if (operLog == null || operLog.getRequestMethod() == null) {
            return false;
        }
        return OperLogConstants.REQUEST_METHOD_DELETE.equals(operLog.getRequestMethod());
    }

    /**
     * 清理模块标题（去除多余空格）
     * 
     * @param operLog 操作日志对象
     * @return 清理后的模块标题
     */
    public static String cleanTitle(SysOperLog operLog) {
        if (operLog == null || operLog.getTitle() == null) {
            return "";
        }
        return OperLogConstants.cleanTitle(operLog.getTitle());
    }

    /**
     * 清理方法名称（去除多余空格）
     * 
     * @param operLog 操作日志对象
     * @return 清理后的方法名称
     */
    public static String cleanMethod(SysOperLog operLog) {
        if (operLog == null || operLog.getMethod() == null) {
            return "";
        }
        return OperLogConstants.cleanMethod(operLog.getMethod());
    }

    /**
     * 清理请求方式（转换为大写）
     * 
     * @param operLog 操作日志对象
     * @return 清理后的请求方式
     */
    public static String cleanRequestMethod(SysOperLog operLog) {
        if (operLog == null || operLog.getRequestMethod() == null) {
            return "";
        }
        return OperLogConstants.cleanRequestMethod(operLog.getRequestMethod());
    }

    /**
     * 清理操作人员（去除多余空格）
     * 
     * @param operLog 操作日志对象
     * @return 清理后的操作人员
     */
    public static String cleanOperName(SysOperLog operLog) {
        if (operLog == null || operLog.getOperName() == null) {
            return "";
        }
        return OperLogConstants.cleanOperName(operLog.getOperName());
    }

    /**
     * 清理IP地址（去除多余空格）
     * 
     * @param operLog 操作日志对象
     * @return 清理后的IP地址
     */
    public static String cleanOperIp(SysOperLog operLog) {
        if (operLog == null || operLog.getOperIp() == null) {
            return "";
        }
        return OperLogConstants.cleanOperIp(operLog.getOperIp());
    }

    /**
     * 获取操作性能等级
     * 
     * @param operLog 操作日志对象
     * @return 性能等级描述
     */
    public static String getPerformanceLevel(SysOperLog operLog) {
        if (operLog == null || operLog.getCostTime() == null) {
            return "未知";
        }
        
        long costTime = operLog.getCostTime();
        if (costTime > 5000) {
            return "慢操作";
        } else if (costTime > 1000) {
            return "较慢";
        } else if (costTime > 500) {
            return "正常";
        } else {
            return "快速";
        }
    }
}
